//db数据库及内部集合和文本编辑代码在app内的onLaunch加载云函数下面
//因为使用云数据库必须确保云函数已经完成连接，所以直接写在云函数调用里面了
//不要使用prompt!!!!!!!下面onLaunch中定义了新的wxPrompt函数输入，格式为wxPrompt(提示1,提示2),如果不用打印提示可以选择不填参数
//下面有很多注释,你应该看得懂
App({
  globalData: {
    env: "cloud1-1g9sc01m2e85b7bb", // 务必确认这是你的真实环境ID
    isRegistered: false // 添加全局注册状态标识
  },

  onLaunch() {
    // 初始化云开发
    wx.cloud.init({
      env: this.globalData.env,
      traceUser: true
    });
    // 测试云函数
    wx.cloud.callFunction({
      name: "login",
      success: (res) => {
        console.log("login云函数返回:", res.result.openid);
      },
      fail: (err) => {
        console.error("login云函数失败:", err);
      }
    });
    // 检查用户权限
    this.checkUserAb();
  },
  //---------------user信息输入------------------//
  async addDataToUsers() {//针对游客权限的用户添加
    const db = wx.cloud.database();//函数内作用域db数据库声明（本来是全局作用域，但是微信云函数之前未连接所以索性直接写云函数调用下面了）
    let userInputName = "";//初始化（因为作者不知道js怎么初始化所以直接全部null好了）
    let userInputGender = "";
    let userInputAge = "";
    let userInputClass = "";
    // 微信小程序兼容的输入函数(因为我发现prompt函数不知道为什么在这用不了所以找ai写了这个兼容微信的输入)
    const wxPrompt = async (title, placeholder = '') => {
      return new Promise(resolve => {
        wx.showModal({
          title,
          editable: true,
          placeholderText: placeholder,
          success: res => {
            if (res.confirm) {
              resolve(res.content);
            } else {
              resolve(null);
            }
          }
        });
      });
    };
    
    // 班级验证函数
    const validateClassInput = (input) => {
      // 检查输入是否为字符串且长度正确（例如 "G1-5" 是4个字符，"A2-10" 是5个字符）
      if (typeof input !== 'string' || (input.length !== 4 && input.length !== 5)) {
          return false;
      }
      // 检查第一个字符是否为 'G' 或 'A'
      const firstChar = input[0];
      if (firstChar !== 'G' && firstChar !== 'A') {
          return false;
      }
      // 检查第二个字符是否为 '1' 或 '2'
      const secondChar = input[1];
      if (secondChar !== '1' && secondChar !== '2') {
          return false;
      }
      // 检查第三个字符是否为 '-'
      const thirdChar = input[2];
      if (thirdChar !== '-') {
          return false;
      }
      // 检查第四个字符开始的数字部分（1-11的开区间，即1-9或10）
      const numberPart = input.slice(3);
      const number = parseInt(numberPart, 10);
      // 检查是否为2-10
      if (isNaN(number) || !(number >= 1 && number <= 10)) {
          return false;
      }
      // 所有检查通过，返回true
      return true;
    };
    
    do{
      userInputName = await wxPrompt("请输入您的姓名", "中文名(如：黄业业)");
    }while(!userInputName || userInputName.length<2 || userInputName.length>4);//姓名判断  
    
    do{
      userInputClass = await wxPrompt("请输入您的班级", "G2-7");
      if(validateClassInput(userInputClass)){
        break;
      }else{
        console.log("班级输入不合法")
        wx.showToast({ title: "班级格式错误", icon: "none" });
      }
    } while(1);
    
    do{
      userInputGender = await wxPrompt("请输入您的性别", "男或女");
      if(userInputGender == "男" || userInputGender == "女"){
        break
      }
      wx.showToast({ title: "请输入男或女", icon: "none" });
    }while(1);//性别判断只有男和女
    
    do{
      userInputAge = await wxPrompt("请输入您的年龄", "13-20之间");
      if(Number(userInputAge)>13 && Number(userInputAge)<20){
        break
      }
      wx.showToast({ title: "年龄需在13-20之间", icon: "none" });
    }while(1);//年龄判断（直接if判断开区间(13,20)年龄）
    //以上input变量全部为大于while的局部变量，所以下面可以直接用

    //-------------user集合操作--------------//

    db.collection('users').add({//对db数据库内users集合添加用户信息文本（在2025-6-18版本还没有引入随机id云函数所以暂时没有写）
      //对db进行添加操作
      data: {
        class: userInputClass,
        gender: userInputGender,
        name: userInputName,
        age: userInputAge,
        createdAt: db.serverDate(),
        ab: 0 //ability,权限设置0为默认值为游客
      },
      //success是判断是否添加成功
      success: (res) => {
        console.log("[成功] 数据已添加", res);
        this.globalData.isRegistered = true; // 标记为已注册
        wx.showToast({ title: "添加成功", icon: "success" });
      },
      //fail是抛出错误代码
      fail: (err) => {
        console.error("[失败] 错误详情:", err);
        wx.showToast({ 
          title: `失败: ${err.errMsg || "未知错误"}`,
          icon: "none" 
        });
      }
    });
  },
  

  //------------以下是登陆检查权限模块--------------//
  async checkUserAb() {
    // 微信小程序兼容的输入函数(因为我发现prompt函数不知道为什么在这用不了所以找ai写了这个兼容微信的输入)
    const wxPrompt = async (title, placeholder = '') => {
      return new Promise(resolve => {
        wx.showModal({
          title,
          editable: true,
          placeholderText: placeholder,
          success: res => {
            if (res.confirm) {
              resolve(res.content);
            } else {
              resolve(null);
            }
          }
        });
      });
    };
    
    // 班级验证函数（从addDataToUsers移植过来）
    const validateClassInput = (input) => {
      // 检查输入是否为字符串且长度正确（例如 "G1-5" 是4个字符，"A2-10" 是5个字符）
      if (typeof input !== 'string' || (input.length !== 4 && input.length !== 5)) {
          return false;
      }
      // 检查第一个字符是否为 'G' 或 'A'
      const firstChar = input[0];
      if (firstChar !== 'G' && firstChar !== 'A') {
          return false;
      }
      // 检查第二个字符是否为 '1' 或 '2'
      const secondChar = input[1];
      if (secondChar !== '1' && secondChar !== '2') {
          return false;
      }
      // 检查第三个字符是否为 '-'
      const thirdChar = input[2];
      if (thirdChar !== '-') {
          return false;
      }
      // 检查第四个字符开始的数字部分（1-11的开区间，即1-9或10）
      const numberPart = input.slice(3);
      const number = parseInt(numberPart, 10);
      // 检查是否为2-10
      if (isNaN(number) || !(number >= 1 && number <= 10)) {
          return false;
      }
      // 所有检查通过，返回true
      return true;
    };
    
    console.log("----------------欢迎使用checkUserAb日志------------------");//日志测试代码，后续可删
    console.log("---------当你看到这行代码，checkUserAb已成功调用----------");
    
    const db = wx.cloud.database();
    try {
      const { result } = await wx.cloud.callFunction({ name: "login" });
      // 获取当前用户openid
      const openid = wx.getStorageSync('openid') || (await wx.cloud.callFunction({name: 'login'})).result.openid;
      const res = await db.collection('users')
        .where({ _openid: openid })
        .field({ ab: true })
        .get();
      console.log(openid);
      if (res.data.length > 0) {//判断是否为有ab值的合法用户
        this.globalData.userAb = res.data[0].ab;
        this.globalData.isRegistered = true; // 标记为已注册

        //------------游客权限------------//
        //游客权限目前只做了申请功能，因为社长权限是先做的，所以为了配对到社团的申请带着做了游客申请
        if (res.data[0].ab === 0) {
          console.log(`[小程序]用户${openid}以游客身份登录，时间：${new Date()}`);
          const userRes = await db.collection('users').where({ _openid: openid }).get();
          if (!userRes.data || userRes.data.length === 0) {
            console.error(`[小程序]未找到用户数据，时间：${new Date()}`);
            wx.showToast({ title: '用户数据异常', icon: 'none' });
            return;
          }
          const userDoc = userRes.data[0];
          wx.showActionSheet({
            itemList: ['我的社团', '我的申请', '我的活动'],
            success: async (res) => {
              if (res.tapIndex === 1) { 
                //-------申请功能菜单--------//
                console.log(`[小程序]用户打开申请菜单，时间：${new Date()}`);
                const { tapIndex: actionIndex } = await new Promise(resolve => {
                  wx.showActionSheet({
                    itemList: ['申请社团', '申请活动', '查看申请状态'],
                    success: resolve,
                    fail: () => resolve({ tapIndex: -1 })
                  });
                });
        
                //-------社团申请处理--------//
                if (actionIndex === 0) {
                  console.log(`[小程序]用户选择申请社团，开始获取社团列表，时间：${new Date()}`);
                  const allClubsRes = await db.collection('clubs').field({ nameClub: true }).get();
                  
                  if (allClubsRes.data.length === 0) {
                    console.log(`[小程序]未找到可申请社团，时间：${new Date()}`);
                    wx.showToast({ title: '暂无社团可申请', icon: 'none' });
                    return;
                  }
        
                  //-------社团选择处理--------//
                  const { tapIndex: clubIndex } = await new Promise(resolve => {
                    wx.showActionSheet({
                      itemList: allClubsRes.data.map(c => c.nameClub),
                      success: resolve,
                      fail: () => resolve({ tapIndex: -1 })
                    });
                  });
        
                  if (clubIndex === -1) {
                    console.log(`[小程序]用户取消社团选择，时间：${new Date()}`);
                    return;
                  }
        
                  //-------申请提交处理--------//
                  console.log(`[小程序]用户提交社团申请，社团ID：${allClubsRes.data[clubIndex]._id}，时间：${new Date()}`);
                  try {
                    await Promise.all([
                      db.collection('users').doc(userDoc._id).update({
                        data: {
                          applications: db.command.push({
                            type: 'club',
                            clubId: allClubsRes.data[clubIndex]._id,
                            status: 'pending',
                            applyTime: db.serverDate()
                          })
                        }
                      }),
                      db.collection('clubs').doc(allClubsRes.data[clubIndex]._id).update({
                        data: {
                          pendingApprovals: db.command.push({
                            applicantId: openid,
                            applicantName: userDoc.name,
                            applyTime: db.serverDate()
                          })
                        }
                      })
                    ]);
                    console.log(`[小程序]社团申请提交成功，时间：${new Date()}`);
                    wx.showToast({ title: '申请已提交', icon: 'success' });
                  } catch (err) {
                    console.error(`[小程序]申请提交失败：${err.message}，时间：${new Date()}`);
                    wx.showToast({ title: '提交失败', icon: 'none' });
                  }
        
                //-------活动申请处理--------//
                } else if (actionIndex === 1) {
                  console.log(`[小程序]用户选择申请活动（功能未实现），时间：${new Date()}`);
                  wx.showToast({ title: '功能开发中', icon: 'none' });
                
                //-------申请状态查看--------//
                } else if (actionIndex === 2) {
                  console.log(`[小程序]用户查看申请状态，开始获取申请数据，时间：${new Date()}`);
                  const userData = await db.collection('users').doc(userDoc._id).get();
                  const applications = userData.data.applications || [];
                  
                  if (applications.length === 0) {
                    console.log(`[小程序]用户无申请记录，时间：${new Date()}`);
                    wx.showToast({ title: '暂无申请记录', icon: 'none' });
                    return;
                  }
        
                  //-------申请分类处理--------//
                  const statusMap = {
                    pending: '待审核',
                    approved: '已通过',
                    rejected: '未通过'
                  };
        
                  //-------申请状态展示--------//
                  const { tapIndex: appIndex } = await new Promise(resolve => {
                    wx.showActionSheet({
                      itemList: applications.map(app => {
                        // 获取社团名称
                        let clubName = '';
                        if (app.type === 'club' && app.clubName) {
                          clubName = `[${app.clubName}]`;
                        }
                        // 格式化时间
                        const applyTime = app.applyTime ? 
                          new Date(app.applyTime).toLocaleDateString() : 
                          '未知时间';
                        return `${statusMap[app.status]} ${clubName} ${applyTime}`;
                      }),
                      success: resolve,
                      fail: () => resolve({ tapIndex: -1 })
                    });
                  });
        
                  if (appIndex === -1) {
                    console.log(`[小程序]用户取消申请详情查看，时间：${new Date()}`);
                    return;
                  }
        
                  const selectedApp = applications[appIndex];
                  console.log(`[小程序]用户查看申请详情，ID：${selectedApp._id}，时间：${new Date()}`);
        
                  //-------申请详情展示--------//
                  let content = `类型：${selectedApp.type === 'club' ? '社团' : '活动'}\n`;
                  content += `状态：${statusMap[selectedApp.status]}\n`;
                  content += `申请时间：${selectedApp.applyTime.toLocaleString()}\n`;
        
                  if (selectedApp.status === 'rejected' && selectedApp.rejectReason) {
                    content += `\n拒绝原因：${selectedApp.rejectReason}`;
                  }
        
                  wx.showModal({
                    title: '申请详情',
                    content: content,
                    showCancel: false,
                    confirmText: '我知道了'
                  });
                }
              }
            },
            fail: (err) => {
              console.log(`[小程序]用户取消菜单选择，时间：${new Date()}`, err);
            }
          });
        //------------游客权限------------//

        //------------社长权限------------//
        } else if(res.data[0].ab === 1){
          console.log("[小程序]欢迎",openid,"以社长登录");
          console.log("[小程序]当前时间",new Date());
          // ------获取社团文档（包含pendingApprovals字段）--------//
          const clubRes = await db.collection('clubs').where({
            _openid: openid
          }).field({
            nameClub: true,
            pendingApprovals: true,
            members: true
          }).get();

          //----------检查社团文档----------//
          if (!clubRes.data || clubRes.data.length === 0) {
            wx.showToast({ title: '未找到社团信息', icon: 'none' });
            console.log("[小程序]未找到相关社团文档",Date());
            return;
          }

          const clubDoc = clubRes.data[0];
          
          //-------pendingApprovals数组-------//
          if (!Array.isArray(clubDoc.pendingApprovals)) {
            clubDoc.pendingApprovals = [];
            await db.collection('clubs').doc(clubDoc._id).update({
              data: {
                pendingApprovals: []
              }
            });
          }

          //------计算待处理申请数量-------//
          const pendingCount = clubDoc.pendingApprovals.length;
          const menuItems = [
            '📝 编辑社团简介',
            '👥 编辑人员名单', 
            '💰 编辑财务支出',
            pendingCount > 0 ? `🆕 待处理申请(${pendingCount})` : '✅ 审核管理'
          ];
          wx.showActionSheet({
            itemList: menuItems,
            async success(res) {
              //--------------------------------------------------------//
              //--------------以下是社长权限下的几个操作选项---------------//
              //-----------没有完整的测试数据可能存在没发现的bug-----------//

              if(res.tapIndex === 3){
                // 🆕 审核管理功能
                try {
                  //-----重新获取最新申请列表-----//
                  const freshClub = (await db.collection('clubs').doc(clubDoc._id).get()).data;
                  const approvals = freshClub.pendingApprovals || [];
                  
                  if(approvals.length === 0){
                    wx.showToast({ title: '暂无待处理申请', icon: 'none' });
                    return;
                  }
                  
                  //-----显示审核操作选项-----//
                  const { tapIndex: actionIndex } = await new Promise(resolve => {
                    wx.showActionSheet({
                      itemList: [
                        '👁️ 查看所有申请',
                        '✅ 一键通过全部',
                        '❌ 一键拒绝全部'
                      ],
                      success: resolve,
                      fail: () => resolve({ tapIndex: -1 })
                    });
                  });                  
                  if(actionIndex === -1) return;
                  if(actionIndex === 0){
                    //显示申请详情
                    for(const approval of approvals){
                      //时间显示
                      const applyTime = approval.applyTime ? 
                        (approval.applyTime.toDate ? approval.applyTime.toDate().toLocaleString() : 
                        typeof approval.applyTime === 'string' ? new Date(approval.applyTime).toLocaleString() : 
                        '未知时间') : '未知时间';
                      
                      const result = await new Promise(resolve => {
                        wx.showModal({
                          title: `👤 ${approval.applicantName || '未知用户'}的申请`,
                          content: `申请时间: ${applyTime}\n\n` +
                                  `附加信息: ${approval.message || '无'}`,
                          confirmText: '通过',
                          cancelText: '拒绝',
                          success: resolve
                        });
                      });
                      
                      if(result.confirm){
                        //通过申请
                        await handleApproval(approval, true);
                      }else{
                        //拒绝申请
                        //拒绝申请需要填写拒绝理由
                        const { confirm, content: reason } = await wxPrompt('请输入拒绝理由', '必填');
                        if(confirm && reason){
                          await handleApproval(approval, false, reason);
                        }
                      }
                    }
                  }else if(actionIndex === 1){
                    //------一键通过------//
                    const { confirm } = await new Promise(resolve => {
                      wx.showModal({
                        title: '确认操作',
                        content: `确定要通过全部 ${approvals.length} 个申请吗？`,
                        success: resolve
                      });

                    });
                    
                    if(confirm){
                      for(const approval of approvals){
                        await handleApproval(approval, true);
                      }
                      wx.showToast({ title: '已通过全部申请', icon: 'success' });
                      console.log("[用户]已通过所有申请",Date());
                    }
                  }else if(actionIndex === 2){
                    //------一键拒绝-----//
                    const { confirm, content: reason } = await wxPrompt('请输入拒绝理由(将应用于全部申请)', '必填');
                    if(confirm && reason){
                      const { confirm: confirmFinal } = await new Promise(resolve => {
                        wx.showModal({
                          title: '确认操作',
                          content: `确定要拒绝全部 ${approvals.length} 个申请吗？`,
                          success: resolve
                        });
                      });
                      
                      if(confirmFinal){
                        for(const approval of approvals){
                          await handleApproval(approval, false, reason);
                        }
                        wx.showToast({ title: '已拒绝全部申请', icon: 'success' });
                        console.log( "[用户]已拒绝所有申请", Date());
                      }
                    }
                  }
                  
                  //------处理单个申请的函数------//
                  async function handleApproval(approval, isApproved, rejectReason = '') {
                    //参数说明： approval为待处理的申请，object类型
                    //参数说明： isApproved为当前申请同意与否，类型为boolean
                    //参数说明:  rejectReason为拒绝理由，仅当isApproved为false时有效
                    try {
                      const db = wx.cloud.database();
                      
                      //------获取最新用户文档检查notifications字段-----//
                      const userRes = await db.collection('users').where({ 
                        _openid: approval.applicantId 
                      }).get();
                      
                      const userDoc = userRes.data[0];
                      
                      //-------确保notifications是数组------//
                      if (userDoc.notifications && !Array.isArray(userDoc.notifications)) {
                        await db.collection('users').doc(userDoc._id).update({
                          data: {
                            notifications: []  //notifications在之前的版本总是出现type错误所以再次确保为数组
                            //notifications时object类型
                            // {
                            //   type: "approved" | "rejected",通知类型
                            //   clubName: "社团名称",相关社团
                            //   message: "通知内容",如"您的申请已通过"
                            //   time: Date,通知时间
                            //   read: false 是否已读
                            // }
                          }
                        });
                      }
                      
                      //---------获取最新社团文档----------//
                      const clubRes = await db.collection('clubs').doc(clubDoc._id).get();
                      const currentClub = clubRes.data;
                      
                      //-----确保pendingApprovals是数组-----//
                      if (!Array.isArray(currentClub.pendingApprovals)) {
                        await db.collection('clubs').doc(clubDoc._id).update({
                          data: {
                            pendingApprovals: []
                          }
                        });
                      }
                      
                      //-------构建社团更新数据-------//
                      const clubUpdate = {
                        pendingApprovals: db.command.pull({
                          applicantId: approval.applicantId
                        }),
                        updatedAt: db.serverDate()
                      };
                      
                      if (isApproved) {
                        clubUpdate.members = db.command.push({
                          userId: approval.applicantId,
                          userName: approval.applicantName,
                          joinTime: db.serverDate()
                        });
                      } else {
                        clubUpdate.rejectedApplications = db.command.push({
                          ...approval,
                          status: 'rejected',
                          rejectReason,
                          processedTime: db.serverDate()
                        });
                      }
                      
                      //--------更新社团文档--------//
                      await db.collection('clubs').doc(clubDoc._id).update({
                        data: clubUpdate
                      });
                      
                      //-----构建用户更新数据------//
                      const userUpdate = {
                        notifications: db.command.push({
                          type: isApproved ? 'approved' : 'rejected',
                          clubName: clubDoc.nameClub || '社团',
                          message: isApproved ? '🎉 您的社团申请已通过！' : `❌ 申请被拒绝: ${rejectReason}`,
                          time: db.serverDate(),
                          read: false
                        })
                      };
                      
                      if (isApproved) {
                        userUpdate.affiliation = db.command.push(clubDoc._id);
                      }
                      
                      //-----更新用户文档-----//
                      await db.collection('users').doc(userDoc._id).update({
                        data: userUpdate
                      });
                      
                    } catch(err) {
                      console.error('处理申请时出错:', err);
                      wx.showToast({ 
                        title: '处理申请时出错，请重试',
                        icon: 'none'
                      });
                      throw err;
                    }
                  }
                } catch(err) {
                  console.error('审核处理失败:', err);
                  wx.showToast({ 
                    title: err.errMsg || '审核处理失败',
                    icon: 'none' 
                  });
                }
              }else if(res.tapIndex === 0){
                try {
                  console.log("[小程序]进入编辑简介",Date());
                  
                  //-----先获取现有的社团文档------//
                  const clubRes = await db.collection('clubs').where({
                    _openid: openid
                  }).get();
                  console.log("[小程序]获取当前社团文档成功",Date());
                  if (clubRes.data.length === 0) {
                    // 如果没有社团文档，创建一个新的
                    const addRes = await db.collection('clubs').add({
                      data: {
                        _openid: openid,
                        text: "", // 初始化简介为空
                        createdAt: db.serverDate(),
                        updatedAt: db.serverDate()
                      },

                    });
                    console.log("[小程序]创建新社团文档成功",Date());
                  }
                  
                  //-----获取当前简介内容作为placeholder------//
                  //placeholder是wx对话框内部内容，类似tips
                  const currentIntro = clubRes.data.length > 0 ? clubRes.data[0].text : "";
                  
                  //------------等待用户输入----------------//
                  const userInputText = await wxPrompt("请输入编辑内容", currentIntro || "编辑内容");
                  console.log("[小程序]用户输入内容:", userInputText);
                  console.log("[小程序]编辑成功",Date());
                  if (userInputText) {
                    //-----更新现有文档而不是创建新文档-----//
                    // console.log("测试点1");
                    const updateRes = await db.collection('clubs').where({
                      _openid: openid
                    }).update({
                      data: {
                        text: userInputText, // 覆盖简介内容
                        updatedAt: db.serverDate()   // 更新修改时间
                      }
                    });
                    // console.log("测试点2");
                    console.log("[小程序]更新成功！", updateRes);
                    wx.showToast({ title: "更新成功", icon: "success" });
                  } else {
                    console.log("[小程序]用户取消输入或输入为空");
                    console.log("测试点3");
                  }
                } catch (err) {
                  console.log("[小程序]编辑失败", err);
                  wx.showToast({ 
                    title: `失败: ${err.errMsg || "未知错误"}`,
                    icon: "none" 
                  });
                }
              //选择添加人员
              } else if(res.tapIndex === 1){//选择编辑人员
                try{
                  console.log("[小程序]编辑人员名单",Date());
                  wx.showActionSheet({//选择对话框
                    itemList:['添加成员','删减成员'],
                    async success(res){
                      console.log("[小程序]",openid,"编辑人员已选择",new Date());
                      if(res.tapIndex === 0){
                        // 修复后的添加成员逻辑
                        let newInputNumber = 0;
                        do{
                          newInputNumber = await wxPrompt("请输入您当前要加入多少个新人员:", "至少为1");
                          newInputNumber = parseInt(newInputNumber);
                          if(isNaN(newInputNumber)) {
                            wx.showToast({ title: "请输入有效数字", icon: "none" });
                            continue;
                          }
                          if(newInputNumber < 1) {
                            wx.showToast({ title: "至少添加1人", icon: "none" });
                          }
                        }while(newInputNumber < 1);
              
                        // 获取当前社团文档ID和已有成员数量
                        let clubDoc = null;
                        let memberCount = 0;
                        try {
                          const clubRes = await db.collection('clubs').where({
                            _openid: openid
                          }).get();
                          
                          if(clubRes.data.length > 0) {
                            clubDoc = clubRes.data[0];
                            memberCount = clubDoc.members ? clubDoc.members.length : 0;
                          } else {
                            // 如果没有找到社团文档，创建一个新的
                            const addRes = await db.collection('clubs').add({
                              data: {
                                _openid: openid,
                                members: [],
                                createdAt: db.serverDate(),
                                updatedAt: db.serverDate()
                              }
                            });
                            clubDoc = { _id: addRes._id, members: [] };
                          }
                        } catch (err) {
                          console.error("获取社团信息失败:", err);
                          wx.showToast({ 
                            title: "获取社团信息失败", 
                            icon: "none" 
                          });
                          return;
                        }
              
                        // 创建成员数组
                        let newMembers = [];
              
                        for(let i=1; i<=newInputNumber; i++){
                          // 姓名输入
                          let memberName = "";
                          do{
                            memberName = await wxPrompt(`请输入第${i}位社员姓名`, "中文名(如：张三)");
                          }while(!memberName || memberName.length<2 || memberName.length>4);
              
                          // 性别输入
                          let memberGender = "";
                          do{
                            memberGender = await wxPrompt(`请输入${memberName}的性别`, "男或女");
                            if(memberGender !== "男" && memberGender !== "女"){
                              wx.showToast({ title: "请输入男或女", icon: "none" });
                            }
                          }while(memberGender !== "男" && memberGender !== "女");
              
                          // 班级输入
                          let memberClass = "";
                          do{
                            memberClass = await wxPrompt(`请输入${memberName}的班级`, "G2-7");
                            if(!validateClassInput(memberClass)){
                              wx.showToast({ title: "班级格式错误", icon: "none" });
                            }
                          }while(!validateClassInput(memberClass));
              
                          // 年龄输入
                          let memberAge = "";
                          do{
                            memberAge = await wxPrompt(`请输入${memberName}的年龄`, "13-20之间");
                            if(Number(memberAge)<=13 || Number(memberAge)>=20){
                              wx.showToast({ title: "年龄需在13-20之间", icon: "none" });
                            }
                          }while(Number(memberAge)<=13 || Number(memberAge)>=20);
              
                          // 将成员信息添加到数组
                          newMembers.push({
                            clubName: "",
                            NO: memberCount + i, // 序号从当前成员数量+1开始
                            name: memberName,
                            gender: memberGender,
                            class: memberClass,
                            age: memberAge,
                            addedBy: openid,
                            addedAt: db.serverDate()
                          });
                        }
              
                        // 更新社团文档中的成员列表
                        try {
                          await db.collection('clubs').doc(clubDoc._id).update({
                            data: {
                              members: db.command.push(newMembers),
                              updatedAt: db.serverDate()
                            }
                          });
                          if(newMembers != 0){
                            wx.showToast({ 
                              title: `成功添加${newMembers.length}位成员`, 
                              icon: "success" 
                            });
                          }
                        } catch (err) {
                          console.error("更新社团成员失败:", err);
                          wx.showToast({ 
                            title: "添加成员失败", 
                            icon: "none" 
                          });
                        }
                      } else {
                        console.log("已选择删减人员",Date());
                        try {
                          //获取当前社团文档
                          const clubRes = await db.collection('clubs').where({
                            _openid: openid
                          }).get();
                          
                          if(clubRes.data.length === 0 || !clubRes.data[0].members || clubRes.data[0].members.length === 0) {
                            wx.showToast({ 
                              title: "当前没有成员可删除", 
                              icon: "none" 
                            });
                            return;
                          }
                          
                          const clubDoc = clubRes.data[0];
                          const currentMembers = clubDoc.members;
                          
                          //输入要删除的成员姓名
                          const nameToDelete = await wxPrompt("请输入要删除的成员姓名", "完整姓名");
                          if(!nameToDelete) {
                            console.log("用户取消输入");
                            return;
                          }
                          
                          //查找匹配的成员
                          const matchedMembers = currentMembers.filter(member => 
                            member.name === nameToDelete.trim()
                          );
                          
                          if(matchedMembers.length === 0) {
                            wx.showToast({ 
                              title: "未找到匹配的成员", 
                              icon: "none" 
                            });
                            return;
                          }
                          
                          //如果找到多个同名成员，让用户选择
                          let memberToDelete = null;
                          if(matchedMembers.length > 1) {
                            const { confirm, content } = await new Promise(resolve => {
                              wx.showModal({
                                title: "发现多个同名成员",
                                content: `共找到${matchedMembers.length}个名为"${nameToDelete}"的成员，请输入要删除的成员序号`,
                                editable: true,
                                success: res => resolve(res)
                              });
                            });
                            
                            if(!confirm) return;
                            
                            const selectedNo = parseInt(content);
                            if(isNaN(selectedNo) || selectedNo < 1 || selectedNo > matchedMembers.length) {
                              wx.showToast({ 
                                title: "请输入有效的序号", 
                                icon: "none" 
                              });
                              return;
                            }
                            
                            memberToDelete = matchedMembers[selectedNo - 1];
                          } else {
                            memberToDelete = matchedMembers[0];
                          }
                          
                          //确认删除
                          const { confirm } = await new Promise(resolve => {
                            wx.showModal({
                              title: "确认删除",
                              content: `确定要删除成员：${memberToDelete.name}（${memberToDelete.class}）吗？`,
                              success: res => resolve(res)
                            });
                          });
                          
                          if(!confirm) return;
                          
                          //执行删除操作
                          const updatedMembers = currentMembers.filter(member => 
                            member.NO !== memberToDelete.NO
                          );
                          
                          await db.collection('clubs').doc(clubDoc._id).update({
                            data: {
                              members: updatedMembers,
                              updatedAt: db.serverDate()
                            }
                          });
                          
                          wx.showToast({ 
                            title: `已成功删除成员:${memberToDelete.name}`, 
                            icon: "success" 
                          });
                          
                        } catch (err) {
                          console.error("删除成员失败:", err);
                          wx.showToast({ 
                            title: "删除成员失败", 
                            icon: "none" 
                          });
                        }
                      }
                    },
                    fail(err) {
                      console.log("用户取消选择", err);
                    }
                  });
                }catch(err){
                  console.error("编辑人员出错:", err);
                  wx.showToast({ 
                    title: `操作失败: ${err.errMsg || "未知错误"}`,
                    icon: "none" 
                  });
                }
              //已选择编辑财务
              } else if(res.tapIndex === 2){
                try {
                  console.log("[小程序]进入财务编辑", new Date());
                  
                  //-------获取社团文档-------//
                  const clubRes = await db.collection('clubs').where({
                    _openid: openid
                  }).get();
                  console.log("[小程序]获取当前社团文档成功",Date());
                  let clubDoc;
                  if (!clubRes.data || clubRes.data.length === 0) {
                    //如果没有社团文档，先创建一个
                    const addRes = await db.collection('clubs').add({
                      data: {
                        _openid: openid,
                        finance: [],
                        createdAt: db.serverDate(),
                        updatedAt: db.serverDate()
                      }
                    });
                    console.log("[小程序]创建新社团文档成功",Date());
                    clubDoc = { _id: addRes._id, finance: [] };
                  } else {
                    clubDoc = clubRes.data[0];
                  }
                  
                  //-------确保finance字段存在---------//
                  if (!clubDoc.finance) {
                    await db.collection('clubs').doc(clubDoc._id).update({
                      data: {
                        finance: [],
                        updatedAt: db.serverDate()
                      }
                    });
                    clubDoc.finance = [];
                    console.log("[小程序]finance字段检查完成",Date());
                  }
                  
                  //-----------财务操作主界面------------//
                  const actionRes = await new Promise(resolve => {
                    wx.showActionSheet({
                      itemList: ['📈 记录收入', '📉 记录支出', '📊 查看流水'],
                      success: resolve,
                      fail: () => resolve({ tapIndex: -1 })
                    });
                    console.log("[小程序]财务编辑菜单弹出成功",Date());
                  });
                  
                  if (actionRes.tapIndex === -1) return;
                  
                  //---------查看流水----------//
                  if (actionRes.tapIndex === 2) {
                    console.log("[小程序]用户已选择查看当前社团流水",Date());
                    const currentClubRes = await db.collection('clubs').doc(clubDoc._id).get();
                    const financeRecords = currentClubRes.data.finance || [];
                    
                    if (financeRecords.length === 0) {
                      wx.showToast({ title: '暂无财务记录', icon: 'none' });
                      console.log("[小程序]当前社团近期暂无财务记录",Date());
                      return;
                    }
                    
                    const currentBalance = financeRecords[financeRecords.length - 1].total || 0;
                    let reportText = `当前余额: ${currentBalance}元\n\n`;
                    console.log("[小程序]余额弹出成功",Date());
                    financeRecords.forEach(record => {
                      const timeStr = record.timeOfChange ? new Date(record.timeOfChange).toLocaleString() : '未知时间';
                      reportText += `${timeStr}\n` +
                                   `${record.type === 'income' ? '➕' : '➖'} ${record.amount}元 ` +
                                   `(${record.reasonOfChange})\n` +
                                   `操作人: ${record.operator || '未知'}\n` +
                                   `余额: ${record.total}元\n\n`;
                    });
                    
                    wx.showModal({
                      title: '财务流水',
                      content: reportText,
                      showCancel: false
                    });
                    return;
                  }
                  //处理收入/支出记录
                  const recordType = actionRes.tapIndex === 0 ? 'income' : 'spending';
                  //-----------输入金额----------//
                  let amount = 0;
                  while (true) {
                    const input = await wxPrompt(
                      `请输入${recordType === 'income' ? '收入' : '支出'}金额`,
                      '请输入正数'
                    );
                    amount = parseFloat(input);
                    if (!isNaN(amount)) {
                      console.log("[小程序]财务编辑成功",Date());
                      if (recordType === 'spending' && amount <= 0) {
                        wx.showToast({ title: '支出金额必须大于0', icon: 'none' });
                        continue;
                      }
                      if (recordType === 'income' && amount < 0) {
                        wx.showToast({ title: '收入金额不能为负', icon: 'none' });
                        continue;
                      }
                      break;
                    }
                    wx.showToast({ title: '请输入有效数字', icon: 'none' });
                  }

                  // 输入用途
                  let reason = '';
                  while (!reason) {
                    reason = await wxPrompt(
                      '请输入用途说明',
                      recordType === 'income' ? '如：社费收入' : '如：购买社团用品'
                    );
                    if (!reason) wx.showToast({ title: '用途不能为空', icon: 'none' });
                    console.log("[小程序]用途编辑成功",Date());
                  }
                  

                  //-------------获取当前余额-------------//
                  const currentClubRes = await db.collection('clubs').doc(clubDoc._id).get();
                  const currentClub = currentClubRes.data;
                  const lastRecord = currentClub.finance.length > 0 
                    ? currentClub.finance[currentClub.finance.length - 1] 
                    : null;
                  const lastBalance = lastRecord ? lastRecord.total : 0;
                  console.log("[小程序]余额计算成功",Date());

                  //--------计算新余额--------//
                  let newBalance;
                  if (recordType === 'income') {
                    newBalance = lastBalance + amount;
                  } else {
                    if (lastBalance < amount) {
                      wx.showToast({ title: '余额不足', icon: 'none' });
                      return;
                    }
                    newBalance = lastBalance - amount;
                  }
                  

                  //----------获取操作人信息----------//
                  const userInfoRes = await db.collection('users').where({ _openid: openid }).get();
                  const userInfo = userInfoRes.data[0];
                  

                  //------------创建新记录-----------//
                  const newRecord = {
                    type: recordType,
                    amount: amount,
                    timeOfChange: db.serverDate(),
                    reasonOfChange: reason,
                    operator: userInfo?.name || '社长',
                    total: newBalance
                  };
                  
                  //----------更新数据库----------//
                  await db.collection('clubs').doc(clubDoc._id).update({
                    data: {
                      finance: db.command.push(newRecord),
                      updatedAt: db.serverDate()
                    }
                  });
                  
                  wx.showToast({ 
                    title: `${recordType === 'income' ? '收入' : '支出'}记录成功`, 
                    icon: 'success' 
                  });
                  
                } catch (err) {
                  console.error('财务操作失败:', err);
                  wx.showToast({ 
                    title: `操作失败: ${err.errMsg || '未知错误'}`,
                    icon: 'none' 
                  });
                }
              }else if(res.tapIndex === 3){
                
              }
            }
          });
        //------------社长权限------------//

        } else if(res.data[0].ab === 2){
          //这里是Ab为2,即当前id的用户是老师权限
          console.log("欢迎",openid,"以老师登录");
          console.log("当前时间",new Date());    
        }else if(res.data[0].ab === 3){ 
          console.log("欢迎",openid,"以学生会登录");
          console.log("当前时间",new Date());
        }
      } else {
        console.log('尚未注册');
        // 未注册用户调用注册流程
        if (!this.globalData.isRegistered) {
          this.addDataToUsers();
        }
      }
    } catch (err) {
      console.error('失败:权限检查失败', err);
      wx.showToast({ 
        title: `权限检查失败: ${err.errMsg || "未知错误"}`,
        icon: "none" 
      });
    }
  }
});
